﻿// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.AspNetCore.Routing;
using Moq;

namespace Microsoft.AspNetCore.Mvc.Filters;

public class PageHandlerResultFilterTest
{
    [Fact]
    public async Task OnResultExecutionAsync_ExecutesAsyncFilters()
    {
        // Arrange
        var pageContext = new PageContext(new ActionContext(
            new DefaultHttpContext(),
            new RouteData(),
            new PageActionDescriptor(),
            new ModelStateDictionary()));
        var model = new Mock<PageModel>();

        var modelAsFilter = model.As<IAsyncResultFilter>();
        modelAsFilter
            .Setup(f => f.OnResultExecutionAsync(It.IsAny<ResultExecutingContext>(), It.IsAny<ResultExecutionDelegate>()))
            .Returns(Task.CompletedTask)
            .Verifiable();

        var resultExecutingContext = new ResultExecutingContext(
           pageContext,
           Array.Empty<IFilterMetadata>(),
           new PageResult(),
           model.Object);
        var resultExecutedContext = new ResultExecutedContext(
            pageContext,
            Array.Empty<IFilterMetadata>(),
            resultExecutingContext.Result,
            model.Object);
        ResultExecutionDelegate next = () => Task.FromResult(resultExecutedContext);

        var pageHandlerResultFilter = new PageHandlerResultFilter();

        // Act
        await pageHandlerResultFilter.OnResultExecutionAsync(resultExecutingContext, next);

        // Assert
        modelAsFilter.Verify();
    }

    [Fact]
    public async Task OnResultExecutionAsync_ExecutesSyncFilters()
    {
        // Arrange
        var pageContext = new PageContext(new ActionContext(
            new DefaultHttpContext(),
            new RouteData(),
            new PageActionDescriptor(),
            new ModelStateDictionary()));
        var model = new Mock<object>();

        var modelAsFilter = model.As<IResultFilter>();
        modelAsFilter
            .Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()))
            .Verifiable();

        modelAsFilter
            .Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()))
            .Verifiable();

        var resultExecutingContext = new ResultExecutingContext(
           pageContext,
           Array.Empty<IFilterMetadata>(),
           new PageResult(),
           model.Object);
        var resultExecutedContext = new ResultExecutedContext(
            pageContext,
            Array.Empty<IFilterMetadata>(),
            resultExecutingContext.Result,
            model.Object);
        ResultExecutionDelegate next = () => Task.FromResult(resultExecutedContext);

        var pageHandlerResultFilter = new PageHandlerResultFilter();

        // Act
        await pageHandlerResultFilter.OnResultExecutionAsync(resultExecutingContext, next);

        // Assert
        modelAsFilter.Verify();
    }

    [Fact]
    public async Task OnPageHandlerExecutionAsync_DoesNotInvokeResultExecuted_IfCancelled()
    {
        // Arrange
        var pageContext = new PageContext(new ActionContext(
            new DefaultHttpContext(),
            new RouteData(),
            new PageActionDescriptor(),
            new ModelStateDictionary()));
        var model = new Mock<object>();

        var modelAsFilter = model.As<IResultFilter>();
        modelAsFilter
            .Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()))
            .Callback((ResultExecutingContext context) => context.Cancel = true)
            .Verifiable();

        modelAsFilter
            .Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()))
            .Throws(new Exception("Shouldn't be called"));

        var resultExecutingContext = new ResultExecutingContext(
           pageContext,
           Array.Empty<IFilterMetadata>(),
           new PageResult(),
           model.Object);
        var resultExecutedContext = new ResultExecutedContext(
            pageContext,
            Array.Empty<IFilterMetadata>(),
            resultExecutingContext.Result,
            model.Object);
        ResultExecutionDelegate next = () => Task.FromResult(resultExecutedContext);

        var pageHandlerResultFilter = new PageHandlerResultFilter();

        // Act
        await pageHandlerResultFilter.OnResultExecutionAsync(resultExecutingContext, next);

        // Assert
        modelAsFilter.Verify();
    }

    [Fact]
    public async Task OnPageHandlerExecutionAsync_InvokesNextDelegateIfHandlerDoesNotImplementFilter()
    {
        // Arrange
        var pageContext = new PageContext(new ActionContext(
            new DefaultHttpContext(),
            new RouteData(),
            new PageActionDescriptor(),
            new ModelStateDictionary()));
        var model = new object();

        var resultExecutingContext = new ResultExecutingContext(
           pageContext,
           Array.Empty<IFilterMetadata>(),
           new PageResult(),
           model);
        var resultExecutedContext = new ResultExecutedContext(
            pageContext,
            Array.Empty<IFilterMetadata>(),
            resultExecutingContext.Result,
            model);
        var invoked = false;
        ResultExecutionDelegate next = () =>
        {
            invoked = true;
            return Task.FromResult(resultExecutedContext);
        };

        var pageHandlerResultFilter = new PageHandlerResultFilter();

        // Act
        await pageHandlerResultFilter.OnResultExecutionAsync(resultExecutingContext, next);

        // Assert
        Assert.True(invoked);
    }
}
